home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / amivogl-1.03.lzh / vogl / drivers / hpdxy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  6.5 KB  |  440 lines
  1. #undef VOGLE
  2.  
  3. /*
  4.  *    DXY & HPGL Driver for vogle/vogl.
  5.  */
  6. #include <stdio.h>
  7. #ifdef VOGLE
  8. #include "vogle.h"
  9. #else
  10. #include "vogl.h"
  11. #endif
  12.  
  13. extern FILE    *_voutfile();
  14.  
  15. static int    plotlstx, plotlsty;    /* position of last draw */
  16.  
  17. static FILE    *fp;
  18.  
  19. #define    P_RESET        0
  20. #define    P_MOVE        1
  21. #define    P_DRAW        2
  22. #define    P_TXTSIZE    3
  23. #define    P_BEGTXT    4
  24. #define    P_ENDTXT    5
  25. #define    P_PEN        6
  26.  
  27. /*
  28.  * basic commands for hpgl
  29.  */
  30. /* 
  31.  * Changed to the delimiters to commas and removed spaces (for older plotter).
  32.  * (mike@penguin.gatech.edu) 
  33.  */
  34. static char    *hpgl[] = {
  35.     "DF;\n",
  36.     "PU%d,%d;\n",
  37.     "PD%d,%d;\n",
  38.     "SI%.4f,%.4f;\n",
  39.     "LB",
  40.     "\003\n",
  41.     "SP%d;\n"
  42. };
  43.  
  44. /*
  45.  * basic commands for dxy
  46.  */
  47. static char    *dxy[] = {
  48.     "",
  49.     "M %d,%d\n",
  50.     "D %d,%d\n",
  51.     "S %d\n",
  52.     "P",
  53.     "\n",
  54.     "J %d\n"
  55. };
  56.  
  57. static char    **plotcmds;
  58.  
  59. /*
  60.  * noop
  61.  *
  62.  *      do nothing but return-1
  63.  */
  64. static int noop(void)
  65. {
  66.     return(-1);
  67. }
  68. /*
  69.  * HPGL_common_init()
  70.  *
  71.  * Performs the common parts of HPGL initialization.
  72.  */
  73. static int HPGL_common_init(
  74.   int minx,
  75.   int maxx,
  76.   int miny,
  77.   int maxy)
  78. {
  79.     vdevice.depth = 4;
  80.  
  81.     fp = _voutfile();
  82.  
  83.     /*
  84.      * The next line is for serial lines if you need to set modes
  85.      */
  86.     fprintf(fp, "\033.(;\033.I81;;17;\033.N;19:IN;");
  87.  
  88.     /*
  89.      * Cause scaling to be 0 to maxX maxY.
  90.      */
  91.     fprintf(fp, "IP%d,%d,%d,%d;", minx, miny, maxx, maxy);
  92.     fprintf(fp, "SC0,%d,0,%d;", vdevice.sizeX, vdevice.sizeY);
  93.  
  94.     plotcmds = hpgl;
  95.     plotlstx = -1111111;
  96.     plotlsty = -1111111;
  97.  
  98.     return(1);
  99. }
  100.  
  101. /*
  102.  * HPGL_init
  103.  *
  104.  *    set up hp plotter. Returns 1 on success.
  105.  */
  106.  
  107. static int HPGL_A4_init(void)
  108. {
  109.     /*
  110.      * A4 paper
  111.      */
  112.     vdevice.sizeX = vdevice.sizeY = 7320;
  113.  
  114.     vdevice.sizeSx = 10200;
  115.     vdevice.sizeSy = 7320;
  116.  
  117.     /* 
  118.      * Changed to 7000 (from 7721) as noted by Michael J. Gourlay 
  119.      * (mike@penguin.gatech.edu) 
  120.      */
  121.     return(HPGL_common_init(-7000, 7000, -7000, 7000));
  122. }
  123.  
  124. static int HPGL_A3_init(void)
  125. {
  126.     /*
  127.      * A3 paper
  128.      */
  129.     vdevice.sizeX = vdevice.sizeY = 10560;
  130.  
  131.     vdevice.sizeSx = 14720; 
  132.     vdevice.sizeSy = 10560; 
  133.  
  134.     return(HPGL_common_init(-10000, 10000, -10000, 10000));
  135. }
  136.  
  137. static int HPGL_A2_init(void)
  138. {
  139.     /*
  140.      * A2 paper
  141.      */
  142.     vdevice.sizeX = vdevice.sizeY = 13440;
  143.  
  144.     vdevice.sizeSx = 18734;
  145.     vdevice.sizeSy = 13440;
  146.  
  147.     return(HPGL_common_init(-13000, 13000, -13000, 13000));
  148. }
  149.  
  150. static int HPGL_A1_init(void)
  151. {
  152.     /*
  153.      * A1 paper
  154.      */
  155.     vdevice.sizeX = vdevice.sizeY = 21360;
  156.  
  157.     vdevice.sizeSx = 29774;
  158.     vdevice.sizeSy = 21360;
  159.  
  160.     return(HPGL_common_init(-21000, 21000, -21000, 21000));
  161. }
  162.  
  163.  
  164. /*
  165.  * DXY_init
  166.  *
  167.  *    set up dxy plotter. Returns 1 on success.
  168.  */
  169. static int DXY_init(void)
  170. {
  171.     fp = _voutfile();
  172.  
  173.     vdevice.sizeX = vdevice.sizeY = 1920; 
  174.  
  175.     vdevice.sizeSx = 2668; 
  176.     vdevice.sizeSy = 1920; 
  177.  
  178.     plotcmds = dxy;
  179.     plotlstx = -1;
  180.     plotlsty = -1;
  181.  
  182.     fprintf(fp, plotcmds[P_RESET]);
  183.  
  184.     return(1);
  185. }
  186.  
  187. /*
  188.  * PLOT_draw
  189.  *
  190.  *    print the commands to draw a line from the current graphics position
  191.  * to (x, y).
  192.  */
  193. static PLOT_draw(
  194.   int x,
  195.   int y)
  196. {
  197.     if (plotlstx != vdevice.cpVx || plotlsty != vdevice.cpVy)
  198.         fprintf(fp, plotcmds[P_MOVE], vdevice.cpVx, vdevice.cpVy);
  199.  
  200.     fprintf(fp, plotcmds[P_DRAW], x, y);
  201.     plotlstx = x;
  202.     plotlsty = y;
  203. }
  204.  
  205. /*
  206.  * PLOT_exit
  207.  *
  208.  *    exit from vogle printing the command to put away the pen and flush
  209.  * the buffer.
  210.  */
  211. static PLOT_exit(void)
  212. {
  213.     fprintf(fp, plotcmds[P_PEN], 0);
  214.     fprintf(fp, "\033.)");
  215.     fflush(fp);
  216.  
  217.     if (fp != stdout)
  218.         fclose(fp);
  219. }
  220.  
  221. /*
  222.  * PLOT_color
  223.  *
  224.  *    change the current pen number.
  225.  */
  226. static PLOT_color(int i)
  227. { 
  228.     fprintf(fp, plotcmds[P_PEN], i);
  229. }
  230.  
  231. /*
  232.  * HPGL_font
  233.  *
  234.  *    load in large or small
  235.  */
  236. static int HPGL_font(char *font)
  237. {
  238.     if (strcmp(font, "small") == 0) {
  239.         vdevice.hwidth = 97.01;    /* Size in plotter resolution units */
  240.         vdevice.hheight = vdevice.hwidth * 2.0;
  241.         fprintf(fp, plotcmds[P_TXTSIZE], 0.16, 0.32);
  242.     } else if (strcmp(font, "large") == 0) {
  243.         vdevice.hwidth = 145.5;
  244.         vdevice.hheight = vdevice.hwidth * 2.0;
  245.         fprintf(fp, plotcmds[P_TXTSIZE], 0.24, 0.48);
  246.     } else 
  247.         return(0);
  248.  
  249.     return(1);
  250. }
  251.  
  252. /*
  253.  * DXY_font
  254.  *
  255.  *    load in large or small.
  256.  */
  257. static int DXY_font(char *font)
  258. {
  259.     if (strcmp(font, "small") == 0) {
  260.         vdevice.hwidth = 24.25;
  261.         vdevice.hheight = vdevice.hwidth * 2.0;
  262.         fprintf(fp, plotcmds[P_TXTSIZE], 3);
  263.     } else if (strcmp(font, "large") == 0) {
  264.         vdevice.hwidth = 36.375;
  265.         vdevice.hheight = vdevice.hwidth * 2.0;
  266.         fprintf(fp, plotcmds[P_TXTSIZE], 5);
  267.     } else 
  268.         return(0);
  269.  
  270.     return(1);
  271. }
  272.  
  273. /*
  274.  * PLOT_char
  275.  *
  276.  *    draw a character.
  277.  */
  278. static PLOT_char(char c)
  279. {
  280.     int    dy, dx;
  281.  
  282.     if (plotlstx != vdevice.cpVx || plotlsty != vdevice.cpVy)
  283.         fprintf(fp, plotcmds[P_MOVE], vdevice.cpVx, vdevice.cpVy);
  284.  
  285.     fprintf(fp, plotcmds[P_BEGTXT]);
  286.  
  287.     fprintf(fp, "%c", c);
  288.  
  289.     fprintf(fp, plotcmds[P_ENDTXT]);
  290.  
  291.     plotlstx = plotlsty = -1111111;
  292. }
  293.  
  294. /*
  295.  * PLOT_string
  296.  *
  297.  *    output a string.
  298.  */
  299. static PLOT_string(char *s)
  300. {
  301.     int        dy, dx;
  302.  
  303.     if (plotlstx != vdevice.cpVx || plotlsty != vdevice.cpVy)
  304.         fprintf(fp, plotcmds[P_MOVE], vdevice.cpVx, vdevice.cpVy);
  305.  
  306.     fprintf(fp, plotcmds[P_BEGTXT]);
  307.  
  308.     fputs(s, fp);
  309.  
  310.     fprintf(fp, plotcmds[P_ENDTXT]);
  311.  
  312.     plotlstx = plotlsty = -1111111;
  313. }
  314.  
  315. /*
  316.  * PLOT_fill
  317.  *
  318.  *      "fill" a polygon
  319.  */
  320. static PLOT_fill(
  321.   int n,
  322.   int x[],
  323.   int y[])
  324. {
  325.     int     i;
  326.  
  327.     if (plotlstx != x[0] || plotlsty != y[0])
  328.         fprintf(fp, plotcmds[P_MOVE], x[0], y[0]);
  329.  
  330.     for (i = 1; i < n; i++)
  331.         fprintf(fp, plotcmds[P_DRAW], x[i], y[i]);
  332.  
  333.     fprintf(fp, plotcmds[P_DRAW], x[0], y[0]);
  334.  
  335.     plotlstx = vdevice.cpVx = x[n - 1];
  336.     plotlsty = vdevice.cpVy = y[n - 1];
  337. }
  338.  
  339. static DevEntry hpgldev = {
  340.     "hpgl",
  341.     "large",
  342.     "small",
  343.     noop,
  344.     PLOT_char,
  345.     noop,
  346.     noop,
  347.     PLOT_color,
  348.     PLOT_draw,
  349.     PLOT_exit,
  350.     PLOT_fill,
  351.     HPGL_font,
  352.     noop,
  353.     noop,
  354.     HPGL_A2_init,
  355.     noop,
  356.     noop,
  357. #ifndef VOGLE
  358.     noop,
  359.     noop,
  360. #endif
  361.     PLOT_string,
  362.     noop,
  363.     noop
  364. };
  365.  
  366. /*
  367.  * _HPGL_devcpy
  368.  *
  369.  *    copy the HPGL device into vdevice.dev.
  370.  */
  371. int _HPGL_A2_devcpy(void)
  372. {
  373. /* if you don't have structure assignment ...
  374.     char    *dev, *tdev, *edev;
  375.  
  376.     dev = (char *)&hpgldev;
  377.     tdev = (char *)&vdevice.dev;
  378.     edev = dev + sizeof(Device);
  379.  
  380.     while (dev != edev)
  381.         *tdev++ = *dev++;
  382. */
  383.     vdevice.dev = hpgldev;
  384. }
  385.  
  386. int _HPGL_A3_devcpy(void)
  387. {
  388.     vdevice.dev = hpgldev;
  389.     vdevice.dev.Vinit = HPGL_A3_init;
  390. }
  391.  
  392. int _HPGL_A4_devcpy(void)
  393. {
  394.     vdevice.dev = hpgldev;
  395.     vdevice.dev.Vinit = HPGL_A4_init;
  396. }
  397.  
  398. int _HPGL_A1_devcpy(void)
  399. {
  400.     vdevice.dev = hpgldev;
  401.     vdevice.dev.Vinit = HPGL_A1_init;
  402. }
  403.  
  404. static DevEntry dxydev = {
  405.     "dxy",
  406.     "large",
  407.     "small",
  408.     noop,
  409.     PLOT_char,
  410.     noop,
  411.     noop,
  412.     PLOT_color,
  413.     PLOT_draw,
  414.     PLOT_exit,
  415.     PLOT_fill,
  416.     DXY_font,
  417.     noop,
  418.     noop,
  419.     DXY_init,
  420.     noop,
  421.     noop,
  422. #ifndef VOGLE
  423.     noop,
  424.     noop,
  425. #endif
  426.     PLOT_string,
  427.     noop,
  428.     noop
  429. };
  430.  
  431. /*
  432.  * _DXY_devcpy
  433.  *
  434.  *    copy the DXY device into vdevice.dev.
  435.  */
  436. int _DXY_devcpy(void)
  437. {
  438.     vdevice.dev = dxydev;
  439. }
  440.